home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / editors / eedraw / src / eep / igraphps.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-29  |  12.8 KB  |  406 lines
  1. /*****************************************************************************
  2. *   General routines to    handle the graphics.                     *
  3. *                                         *
  4. * Written by:  Gershon Elber                   Ver 0.1, Oct. 1989    *
  5. *                                         *
  6. * Support: PostScript to standard output.                     *
  7. *****************************************************************************/
  8.  
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <ctype.h>
  12. #include <time.h>
  13.  
  14. #ifdef __MSDOS__
  15. #include <io.h>
  16. #include <fcntl.h>
  17. #include <bios.h>
  18. #include <dos.h>
  19. #include <conio.h>
  20. #include <sys\types.h>
  21. #else
  22. #include <sys/types.h>
  23. #endif /* __MSDOS__ */
  24.  
  25.  
  26. #include "program.h"
  27. #include "igraph.h"
  28.  
  29. #define PS_PSIZE_X 1024                                         /* In points. */
  30. #define PS_PSIZE_Y 640
  31.  
  32. #define PS_ISIZE_X 10.0                                         /* In inches. */
  33. #define PS_ISIZE_Y 6.25
  34.  
  35. #define PS_NORMAL_FONT_SIZE    12
  36.  
  37. static TextOrientationType TextOrientation = TEXT_ORIENT_HORIZ;
  38. static int TextScale = 1;
  39. static TextHorizJustifyType TextXCenter = TEXT_X_CENTER;
  40. static TextVertJustifyType TextYCenter = TEXT_Y_CENTER;
  41.  
  42. static int CursorX, CursorY;
  43. static int GraphicMode = FALSE;
  44.  
  45. static void IGSetFontSize(int Size);
  46.  
  47. /****************************************************************************
  48. * Routine to reset all the system to starting condition    :            *
  49. ****************************************************************************/
  50. void IGInitGraph(void)
  51. {
  52.     static char *PSHeader[] = {
  53.     "%!PS-Adobe-2.0 EPSF-1.2",
  54.     "%%BoundingBox: 36 36 540 756",    /* 7x10 inches, LL at [0.5, 0.5]. */
  55.     "%%Title:",
  56.     "%%Creator: EED-PS",
  57.     "%%CreationDate:",
  58.     "%%EndComments",
  59.     "%%\n",
  60.     "/line {",
  61.     "    newpath",
  62.     "    moveto",
  63.     "    lineto",
  64.     "    stroke",
  65.     "} def\n",
  66.     "gsave",
  67.     "1 setlinewidth",
  68.     "1 setlinecap",
  69.     "1 setlinejoin",
  70.     "72 72 scale\t\t\t\t%% Talk inches",
  71.     "7.0 10.5 translate -90 rotate\t\t%% 0.5 inch border from all sides",
  72.     NULL
  73.     };
  74.     int i;
  75.     time_t time1970 = time(NULL);
  76.  
  77.  
  78.     for (i = 0; PSHeader[i] != NULL; i++) {
  79.     if (strcmp(PSHeader[i], "%%Title:") == 0)
  80.         printf("%s %s\n", PSHeader[i], EEDataFileName);
  81.     else if (strcmp(PSHeader[i], "%%CreationDate:") == 0)
  82.         printf("%s %s", PSHeader[i], ctime(&time1970));
  83.     else
  84.         printf("%s\n", PSHeader[i]);
  85.     }
  86.  
  87.     printf("%lf %lf scale\t\t%% Move to EED coordinates\n",
  88.             PS_ISIZE_X / PS_PSIZE_X, -PS_ISIZE_Y / PS_PSIZE_Y);
  89.  
  90.     IGSetFontSize(PS_NORMAL_FONT_SIZE);                  /* Select font. */
  91.  
  92.     GraphicMode = TRUE;
  93. }
  94.  
  95. /****************************************************************************
  96. * Routine to close and shutdown    graphic    mode :                    *
  97. ****************************************************************************/
  98. void IGCloseGraph(void)
  99. {
  100.     if (GraphicMode) {
  101.     printf("showpage\n");
  102.     printf("grestore\n");
  103.  
  104.     GraphicMode = FALSE;
  105.     }
  106. }
  107. /****************************************************************************
  108. * Routine to set a font size.                            *
  109. ****************************************************************************/
  110. static void IGSetFontSize(int Size)
  111. {
  112.     printf("/%s findfont [%d 0 0 -%d 0 0] makefont setfont\n",
  113.        EEPSFontName, Size, Size);
  114.     printf("/stringheight %d def\n", (int) (0.65 * PS_NORMAL_FONT_SIZE));
  115. }
  116.  
  117. /****************************************************************************
  118. * Routine to map drawing x coordinate into screen space.            *
  119. ****************************************************************************/
  120. int IGMapX(int x)
  121. {
  122.     return x >> IG_DEFAULT_ZOOM_FACTOR;
  123. }
  124.  
  125. /****************************************************************************
  126. * Routine to map drawing y coordinate into screen space.            *
  127. ****************************************************************************/
  128. int IGMapY(int y)
  129. {
  130.     return y >> IG_DEFAULT_ZOOM_FACTOR;
  131. }
  132.  
  133. /****************************************************************************
  134. * Routine to move to a new position, as in Drawing space.            *
  135. ****************************************************************************/
  136. void IGMoveTo(int x, int y)
  137. {
  138.     CursorX = IGMapX(x);
  139.     CursorY = IGMapY(y);
  140. }
  141.  
  142. /****************************************************************************
  143. * Routine to draw to a new position, as in Drawing space.            *
  144. ****************************************************************************/
  145. void IGLineTo(int x, int y)
  146. {
  147.     int NewX, NewY;
  148.  
  149.     printf("%d %d %d %d line\n\n", CursorX, CursorY,
  150.                     NewX = IGMapX(x), NewY = IGMapY(y));
  151.     CursorX = NewX;
  152.     CursorY = NewY;
  153. }
  154.  
  155. /****************************************************************************
  156. * Routine to draw a line between the two given points.                *
  157. ****************************************************************************/
  158. void IGLine(int x1, int y1, int x2, int y2)
  159. {
  160.     printf("%d %d %d %d line\n\n", IGMapX(x1), IGMapY(y1),
  161.                    IGMapX(x2), IGMapY(y2));
  162. }
  163.  
  164. /****************************************************************************
  165. * Routine to draw a new polyline and fill it if Fill.                *
  166. ****************************************************************************/
  167. void IGPoly(int n, int *Points, int Fill)
  168. {
  169.     int i;
  170.  
  171.     printf("newpath\n");
  172.     printf("%d %d moveto\n", IGMapX(Points[0]), IGMapY(Points[1]));
  173.     for (i = 1; i < n; i++) {
  174.     printf("%d %d lineto\n", IGMapX(Points[i * 2]),
  175.                  IGMapY(Points[i * 2 + 1]));
  176.     }
  177.  
  178.     if (Fill)
  179.     printf("closepath fill\n\n");
  180.     else
  181.     printf("stroke\n\n");
  182. }
  183.  
  184. /****************************************************************************
  185. * Routine to draw a bar, as in Drawing space.                    *
  186. ****************************************************************************/
  187. void IGBar(int x1, int y1, int x2, int y2)
  188. {
  189.     x1 = IGMapX(x1);
  190.     y1 = IGMapY(y1);
  191.     x2 = IGMapX(x2);
  192.     y2 = IGMapY(y2);
  193.     printf("newpath\n");
  194.     printf("%d %d moveto\n", x1, y1);
  195.     printf("%d %d lineto\n", x1, y2);
  196.     printf("%d %d lineto\n", x2, y2);
  197.     printf("%d %d lineto\n", x2, y1);
  198.     printf("%d %d lineto\n", x1, y1);
  199.     printf("closepath fill\n\n");
  200. }
  201.  
  202. /****************************************************************************
  203. * Routine to draw a circle, as in Drawing space.                *
  204. ****************************************************************************/
  205. void IGCircle(int x, int y, int r)
  206. {
  207.     printf("newpath %d %d %d 0 360 arc stroke\n\n", IGMapX(x), IGMapY(y),
  208.                         r >> IG_DEFAULT_ZOOM_FACTOR);
  209. }
  210.  
  211. /****************************************************************************
  212. * Routine to draw an arc, as in Drawing space.                    *
  213. * As the Y axes is inverted the Angles should be inverted as well.        *
  214. ****************************************************************************/
  215. void IGArc(int x, int y, int StAngle, int EndAngle, int r)
  216. {
  217.     printf("newpath %d %d %d %d %d arc stroke\n\n", IGMapX(x), IGMapY(y),
  218.                 r >> IG_DEFAULT_ZOOM_FACTOR, StAngle, EndAngle);
  219. }
  220.  
  221. /****************************************************************************
  222. * Routine to draw the given text in current cursor position.            *
  223. ****************************************************************************/
  224. void IGText(char *s)
  225. {
  226.     printf("\n%d %d moveto (%s)\n", CursorX, CursorY, s);
  227.  
  228.     if (TextScale > 1)
  229.     IGSetFontSize(PS_NORMAL_FONT_SIZE * TextScale);          /* Select font. */
  230.  
  231.     switch (TextXCenter) {
  232.     case TEXT_X_LEFT:
  233.         switch (TextOrientation) {
  234.         case TEXT_ORIENT_HORIZ:
  235.             break;
  236.         case TEXT_ORIENT_VERT:
  237.             printf("stringheight 2 add 0 rmoveto\n");
  238.             break;
  239.         }
  240.         break;
  241.     case TEXT_X_CENTER:
  242.         switch (TextOrientation) {
  243.         case TEXT_ORIENT_HORIZ:
  244.             printf("dup stringwidth pop 2 div neg 0 rmoveto\n");
  245.             break;
  246.         case TEXT_ORIENT_VERT:
  247.             printf("stringheight 2 div 0 rmoveto\n");
  248.             break;
  249.         }
  250.         break;
  251.     case TEXT_X_RIGHT:
  252.         switch (TextOrientation) {
  253.         case TEXT_ORIENT_HORIZ:
  254.             printf("dup stringwidth pop neg -2 add 0 rmoveto\n");
  255.             break;
  256.         case TEXT_ORIENT_VERT:
  257.             break;
  258.         }
  259.         break;
  260.     }
  261.  
  262.     switch (TextYCenter) {
  263.     case TEXT_Y_BOTTOM:
  264.         switch (TextOrientation) {
  265.         case TEXT_ORIENT_HORIZ:
  266.             printf("0 -2 rmoveto\n");
  267.             break;
  268.         case TEXT_ORIENT_VERT:
  269.             break;
  270.         }
  271.         break;
  272.     case TEXT_Y_CENTER:
  273.         switch (TextOrientation) {
  274.         case TEXT_ORIENT_HORIZ:
  275.             printf("0 stringheight 2 div rmoveto\n");
  276.             break;
  277.         case TEXT_ORIENT_VERT:
  278.             printf("dup stringwidth pop 2 div 0 exch rmoveto\n");
  279.             break;
  280.         }
  281.         break;
  282.     case TEXT_Y_TOP:
  283.         switch (TextOrientation) {
  284.         case TEXT_ORIENT_HORIZ:
  285.             printf("0 stringheight 2 add rmoveto\n");
  286.             break;
  287.         case TEXT_ORIENT_VERT:
  288.             printf("dup stringwidth pop 0 exch rmoveto\n");
  289.             break;
  290.         }
  291.         break;
  292.     }
  293.  
  294.     switch (TextOrientation) {
  295.     case TEXT_ORIENT_HORIZ:
  296.         printf("show\n");
  297.         break;
  298.     case TEXT_ORIENT_VERT:
  299.         printf("gsave -90 rotate show grestore\n");
  300.         break;
  301.     }
  302.  
  303.     if (TextScale > 1)
  304.     IGSetFontSize(PS_NORMAL_FONT_SIZE);              /* Select font. */
  305.     printf("\n");
  306. }
  307.  
  308. /****************************************************************************
  309. * Routine to set attributes - horiz./vert. and centering.            *
  310. ****************************************************************************/
  311. void IGTextFormat(TextOrientationType Orient, int Scale,
  312.           TextHorizJustifyType XCenter, TextVertJustifyType YCenter)
  313. {
  314.     TextOrientation = Orient;
  315.     TextScale = Scale;
  316.     TextXCenter = XCenter;
  317.     TextYCenter = YCenter;
  318. }
  319.  
  320. /****************************************************************************
  321. * Routine to draw the not bar above a negated text.                *
  322. * As in postscript the font is not fixed size we will let it figure the     *
  323. * second coordinate (x2, y2) accoring to Str real length.            *
  324. * We assume (x1, y1) are correct.                        *
  325. ****************************************************************************/
  326. void IGDrawNotBar(int x1, int y1, int x2, int y2, char *Str)
  327. {
  328.     /* For some reason this special justification is somewhat off so here is */
  329.     /* a kluge to fix this one.                             */
  330.     if (y2 == 0 && x2 < 0) x1 -= 3;
  331.  
  332.     /* Push first coordinate of line and then push real string width         */
  333.     /* using postscript stringwidth operator.                     */
  334.     printf("%d %d (%s) stringwidth pop ", x1, y1, Str);
  335.  
  336.     /* Detect the orientation from the coordinates: */
  337.     if (x2 == 0) {                     /* Its a vertical line. */
  338.     if (y2 < 0) {                     /* It is top justified. */
  339.         printf("neg %d add %d exch line\n", y1, x1);
  340.     }
  341.     else {                      /* It is bottom justified. */
  342.         printf("%d add %d exch line\n", y1, x1);
  343.     }
  344.     }
  345.     else {                      /* Its an horizontal line. */
  346.     if (x2 < 0) {                   /* It is right justified. */
  347.         printf("neg %d add %d line\n", x1, y1);
  348.     }
  349.     else {                        /* It is left justified. */
  350.         printf("%d add %d line\n", x1, y1);
  351.     }
  352.     }
  353. }
  354.  
  355. /****************************************************************************
  356. * Routine to set color to color within range.                    *
  357. ****************************************************************************/
  358. void IGSetColor(int Color)
  359. {
  360. }
  361.  
  362. /*****************************************************************************
  363. *   Relative line to in screen coordinates.                     *
  364. *****************************************************************************/
  365. void IGLineRelToNoMap(int x, int y)
  366. {
  367.     printf("%d %d %d %d line\n\n", CursorX, CursorY, CursorX + x, CursorY + y);
  368.     CursorX += x;
  369.     CursorY += y;
  370. }
  371.  
  372. /*****************************************************************************
  373. *   Move to in screen coordinates.                         *
  374. *****************************************************************************/
  375. void IGMoveToNoMap(int x, int y)
  376. {
  377.     CursorX = x;
  378.     CursorY = y;
  379. }
  380.  
  381. /*****************************************************************************
  382. *   Line in screen coordinates.                             *
  383. *****************************************************************************/
  384. void IGLineNoMap(int x1, int y1, int x2, int y2)
  385. {
  386.     printf("%d %d %d %d line\n\n", x1, y1, x2, y2);
  387. }
  388.  
  389. /*****************************************************************************
  390. *   Returns text width in screen coordinates.                     *
  391. * We need to approximate here as this is not fixed size font...             *
  392. *****************************************************************************/
  393. int IGTextWidthNoMap(char *s)
  394. {
  395.     return strlen(s) * 6 * TextScale;
  396. }
  397.  
  398. /*****************************************************************************
  399. *   Returns text height in screen coordinates.                     *
  400. * We need to approximate here as this is not fixed size font...             *
  401. *****************************************************************************/
  402. int IGTextHeightNoMap(char *s)
  403. {
  404.     return 8 * TextScale;
  405. }
  406.